<!DOCTYPE html>
<html>

<head>
	<meta charset="utf-8">
	<title></title>
</head>

<body>
	<div>深克隆：<span id="skl"></span></div>
	<div>冒泡排序：<span id="mppx"></span></div>
	<script type="text/javascript">
		/*
			基本类型：string,number,boolean,null,undefined,symbol
			引用类型：Function,Array,Object
				基本类型存在栈里面，引用类型存在堆里面，但包括基本类型
			数据类型：string,number,boolean,null,undefined,Object
		*/
		//多选和删除总结===================
		/* 
			多选：
				全选-反选-全选取消一个，不全选-不全选全部勾上变全选
			删除：
				基本方法：splice(从哪个开始，删除多少个)
					没高亮带动画的删除：虚拟dom添加class，然后执行splice
					有高亮带动画的删除：
						也是虚拟dom，一开始把高亮的先记录下来，删除之前先取消高亮，删除想要删的那个，
						如果之前记录的坐标存在，
							并且传进去的索引小于当前记录的，直接操作-1然后重新记录索引，如果有相关渲染交互，不触发这些交互
							如果传进去的与当前记录的相等，直接操作当前，并触发渲染交互
							不相等，直接操作当前，不触发渲染交互
						不存在的情况，
							删除其他的时候，一开始选中的最后一个，如果存在上一个，就-1然后高亮，重新记录索引
							否则删除了之后直接清空当前写入的信息或其他交互
		 */


		// 请把两个数组 ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2'] 和 ['A', 'B', 'C', 'D']，合并为 ['A1', 'A2', 'A', 'B1', 'B2', 'B', 'C1', 'C2', 'C', 'D1', 'D2', 'D']=============================================================================================
		/*
		let arr0 = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2']
		let arr1 = ['A', 'B', 'C', 'D']

		var handle = function(arra,arrb){
			let res = arrb.map((item,index) => {
				return [arra[index * 2],arra[index*2+1],item]
			})
			return [].cancat(...res)
		}
		console.log(handle(arr0,arr1))
		*/


		//如下：{1:222, 2:123, 5:888}，请把数据处理为如下结构：[222, 123, null, null, 888, null, null, null, null, null, null, null]===============================================================================================
		// let obj = {1:222, 2:123, 5:888};
		// const result = Array.from({ length: 12 }).map((_, index) => obj[index + 1] || null);
		// console.log(result)


		//对象层级化
		var arr = [
			{ id: 1, parentid: -1, value: 1 },
			{ id: 2, parentid: 1, value: 2 },
			{ id: 3, parentid: 1, value: 3 },
			{ id: 4, parentid: 3, value: 4 },
		]
		function translateDataToTree(data, parentId = '') {
			let tree = []
			let temp
			data.forEach((item, index) => {
				if (data[index].parentid === parentId) {
					let obj = data[index]
					temp = translateDataToTree(data, data[index].id)
					if (temp.length > 0) {
						obj.children = temp
					}
					tree.push(obj)
				}
			})
			return tree
		}


		//求交集===========================================================================
		const com = (nums1, nums2) => {
			const map = {}
			const res = []
			for (let n of nums1) {
				if (map[n]) {
					map[n]++
				} else {
					map[n] = 1
				}
			}
			for (let n of nums2) {
				if (map[n] > 0) {
					res.push(n)
					map[n]--
				}
			}
			return res
		}

		var nums1 = [1, 1]
		var nums2 = [1]
		com(nums1, nums2)


		//大小写取反=============================================================================
		function processString(s) {
			var arr = s.split('');
			var new_arr = arr.map((item) => {
				return item === item.toUpperCase() ? item.toLowerCase() : item.toUpperCase();
			});
			return new_arr.join('');
		}
		console.log(processString('AbC'));


		//字符串S是否存在字符串T==============================================================
		const find = (S, T) => {
			if (S.length < T.length) return -1
			for (let i = 0; i < S.length; i++) {
				if (S.slice(i, i + T.length) === T) return i
			}
			return -1
		}



		// 扁平化数组和排序===========================================================================
		var arrs = [[[[[[1, 2]]]]], 3, 4, [[[{ a: 555 }, 5, 6]]], 7, 8]
		console.log(arrs.toString().split(",").sort((a, b) => { return a - b }).map(Number))
		/*
			Array.from(new Set(arr.flat(Infinity)))，高版本浏览器支持的扁平化数组
			//手写flat转化方式
			var arrs = [[[[[[1,2]]]]],3,4,[[[{a:555},5,6]]],7,8]
			Array.prototype.reduce = function(fn, init) {
				var arr = this   // this就是调用reduce方法的数组
				var total =  init || arr[0]   // 有初始值使用初始值
				// 有初始值的话从0遍历， 否则从1遍历
				for (var i = init ? 0 : 1; i < arr.length; i++) {
					total = fn(total, arr[i], i , arr)
				} 
				return total
			}
			Array.prototype.myFlat = function (dep = 1) {

				return this.reduce((acc, val) => {
							
					return  acc.concat(Array.isArray(val) && dep > 0 ? 
							// 这里的三目就是防止这个现象：[3].concat([4]) // 结果为[3, 4]
							val.myFlat(--dep) : Array.isArray(val) ? [val] : val);

				}, [])
			}
		*/


		//深克隆==============================
		var objs = { a: 1, b: [2, 4, { ms: '32432' }, { fn: function () { } }], psv: null, remv: undefined };
		function depcl(obj) {
			let newObj = Array.isArray(obj) ? [] : {};
			if (obj && typeof obj === "object") {
				for (let key in obj) {
					if (obj.hasOwnProperty(key)) {
						newObj[key] =
						obj && typeof obj[key] === "object" ? depcl(obj[key]) : obj[key];
					}
				}
			}
			return newObj;
		}
		/* 函数和undefined无法转字符串出来 */
		document.getElementById('skl').innerHTML = JSON.stringify(depcl(objs));


		//排序相关========================================
		var ArraySort = function () {
			this.publicsort = function (arrs, m, n) {
				var temp = arrs[m]
				arrs[m] = arrs[n]
				arrs[n] = temp
				return arrs
			}
			//冒泡排序（重点记）
			this.bubule = function (arrs) {
				var arr = arrs
				for (var i = 0; i < arr.length; i++) {
					for (var k = 0; k < arr.length - i; k++) {
						if (arr[k] < arr[k - 1]) {/* 这个符号是关键点 *///数组里面如果是对象的话，对象id在这处理
							arr = this.publicsort(arr, k, k - 1)
						}
					}
				}
				document.getElementById('mppx').innerHTML = JSON.stringify(arr)
			}
			//选择排序
			this.selects = function (arrs) {
				var arr = arrs
				for (var i = 0; i < arr.length - 1; i++) {
					var min = i//先一开始记录一个，用来下面那层的比较
					for (var k = min + 1; k < arr.length; k++) {
						if (arr[min] > arr[k]) {/* 这个符号是关键点 *///数组里面如果是对象的话，对象id在这处理
							min = k
						}
					}
					arr = this.publicsort(arr, min, i)
				}
			}
			//插入排序
			this.insert = function (arrs) {
				var arr = arrs
				for (var i = 1; i < arr.length; i++) {
					var temp = arr[i]//先取出来，用来比较
					var j = i
					while (arr[j - 1] > temp && j > 0) {//数组里面如果是对象的话，对象id在这处理
						//进行位移
						arr[j] = arr[j - 1]
						j--;
					}
					//把temp放置到j即可
					arr[j] = temp
				}
			}
			/*  */
			//希尔排序
			this.shell = function (arrs) {
				var arr = arrs
				//初始化增量(间隔/间隙)
				var gap = Math.floor(arrs.length / 2)
				//while循环（gap不断减小）
				while (gap >= 1) {
					//以gap作为间隔，进行分组，对分组进行插入排序
					for (var i = gap; i < arr.length; i++) {
						var temp = arr[i]//先取出来，用来比较
						var j = i
						while (arr[j - gap] > temp && j > 0) {//数组里面如果是对象的话，对象id在这处理
							//进行位移
							arr[j] = arr[j - gap]
							j -= gap;
						}
						//把temp放置到j即可
						arr[j] = temp
					}
					//重置gap
					gap = Math.floor(gap / 2)
				}

			}
			//快速排序
			this.quick = function (arrs, left, right) {
				var ary = arrs
				if (left >= right) {
					return ary;
				}

				var i = left,
					j = right;
				base = ary[left];

				while (i < j) {
					// 从右边起，寻找比基数小的数
					while (i < j && ary[j] >= base) {//数组里面如果是对象的话，对象id在这处理
						j--;
					}

					// 从左边起，寻找比基数大的数
					while (i < j && ary[i] <= base) {//数组里面如果是对象的话，对象id在这处理
						i++
					}

					if (i < j) {
						var temp = ary[i];
						ary[i] = ary[j];
						ary[j] = temp;
					}
				}

				ary[left] = ary[i];
				ary[i] = base;

				this.quick(ary, left, i - 1);
				this.quick(ary, i + 1, right);

				return ary;
			}
			this.quickSort = function (arrs) {
				var arr = arrs
				this.quick(arr, 0, arr.length - 1)
			}
		}
		var thearr = [4, 5, 6, 3, 4, 6, 2, 4, 7, 3, 4]
		var arraySort = new ArraySort()
		var mtds = ['bubule', 'selects', 'insert', 'shell', 'quickSort']//排序种类的方法，在下面遍历调用
		mtds.map(function (v, i) { arraySort[v] ? arraySort[v]([].concat(thearr)) : '' })


		//时间戳纯计算处理==========================================================

		/* 时间戳 */
		var timestrmp = 201600000
		// 总秒数
		var second = Math.floor(timestrmp / 1000);

		// 天数
		var day = Math.floor(second / 3600 / 24);
		// 小时
		var hr = Math.floor(second / 3600 % 24);
		// 分钟
		var min = Math.floor(second / 60 % 60);
		// 秒
		var sec = Math.floor(second % 60);

		console.log(day, hr, min, sec)

		//链条查找直属父级id返回当前id和父级id===============================================================
		function fn(id, list) {
			const match = list.find(item => item.id === id);
			if (match) return [id];
			const sub = list.find(item => id.startsWith(item.id));
			return [sub.id].concat(fn(id, sub.children));
		}
		//或者
		let fn = (function () {
			let map = null;
			let findMap = (data, searchkey, ids, map = {}) => {
				data.forEach(item => {
					map[item[searchkey]] = map[item[searchkey]] || [];
					if (ids) {
						map[item[searchkey]] = ids.concat(item[searchkey]);
					} else {
						map[item[searchkey]].push(item[searchkey]);
					}
					if (item.children) {
						return findMap(item.children, searchkey, map[item[searchkey]], map);
					}
				});
				return map;
			}
			return function (list, value, searchkey) {
				if (!map) {
					map = findMap(list, searchkey);
				}
				return map[value];
			}
		})();
			//fn(数据，唯一的数据属性)
        //括号是否成对判断=========================================================================
        var fnkuos = (s) => {
            var stack = []
            for(var i=0;i<s.length;i++){
                if(s[i] == '(' || s[i] == '[' || s[i] == '{' || s[i] == ')' || s[i] == ']' || s[i] == '}'){
                    var start = s[i]
                    if(s[i] == '(' || s[i] == '[' || s[i] == '{') stack.push(s[i])
                    else {
                        var end = stack[stack.length - 1];
                        if(start == ')' && end == '(' ||start == ']' && end == '[' || start == '}' && end == '{'){
                            stack.pop()
                        }else{
                            return false;
                        }
                    }
                }
            }
            return stack.length == 0
        }
        //链表：a-b-c-d============================================================================
        //链表倒转：思路：第一个后面抽出来存起来-给第一个的next写入中间值-将中间值等于当前遍历的对象-并重置当前遍历对象为之前存起来的第一个的next
        var lianlistresvre = (objlist)=>{
            var prev = null//中间值
            var cur = objlist
            while(cur){
                var next = cur.next//第一个后面的存起来
                cur.next = prev//第一个的next写入中间值
                prev = cur//将当前被改变的遍历对象存到中间值
                cur = next//将之前存起来的next作为新的遍历对象赋值进去
            }
            return prev//返回中间值
        }
        //查找字符串当中的最长子串==================================================================
        var getlongsubstr = (arr)=>{
            const maps = new Map()
            let l = 0;
            let num = 0;
            for(let i=0;i<arr.length;i++){
                var v = arr[i]
                if(maps.has(v) && maps.get(v) >= l){
                    l = maps.get(v)+1
                }
                num = Math.max(num,i+1-l)
                maps.set(v,i)
            }
            return num
        }
        //二叉树处理以及红黑树======================================================================
        //深度
        var fnEr1 = (node)=>{
            if(!node){
                return;
            }
            //前序
            console.log(node.val)
            fnEr(node.left)
            fnFr(node.right)
            //中序
            // fnEr(node.left)
            // console.log(node.val)
            // fnFr(node.right)
            //后序
            // fnEr(node.left)
            // fnFr(node.right)
            // console.log(node.val)
        }
        //广度
        var fnEr2 = ( node) => {
            var result = []//最终返回的数组
            var firstres = []//桥接数组
            while(firstres.length){
                var current = firstres.shift()//删除并返回被删除的第一个出来，去查有没有左右
                result.push(current.val)
                //如果有的话继续
                if(current.left){
                    firstres.push(current.left)
                }
                if(current.right){
                    firstres.push(current.right)
                }
            }
            return result
        }
        //红黑树
        /*
            红黑树是基于对二叉树的旋转使得二叉树的高度平衡的思想进行处理的衍生算法模型
        */
        //js动画替代方案========================================================
        function anifn(){
            requestAnimationFrame(()=>{
                anifn()
            })
        }
        //角度计算总结=========================================================
        var angleget = (y, x) => {
            var radian = Math.atan2(y, x); // 返回来的是弧度\
            var angle = 180 / Math.PI * radian; // 根据弧度计算角度
            var trueangle = (angle >= 0 && angle <= 180) ? angle : 360 + angle
            //向右旋转90度
            var angle90deg =
                trueangle >= 90 && trueangle < 360 ? trueangle - 90 :
                    trueangle + 270
            console.log(angle90deg)
        }
        //以下情况是0在左边的情况
        // angleget(100 - 100, 100 - 50)//y1-y2,x1-x2，原点和目标点水平位置的角度
        //100 - 100, 100 - 50 -- 0
        //100 - 50, 100 - 50 -- 45
        //100 - 50, 100 - 100 -- 90
        //100 - 50, 100 - 150 -- 135
        //100 - 100, 100 - 150 -- 180
        //100 - 150, 100 - 150 -- 225
        //100 - 150, 100 - 100 -- 270
        //100 - 150, 100 - 50 -- 315
        //100 - 100, 100 - 50 -- 360
        //以下情况是0在上面时候的值
        //angleget(100 - 50, 100 - 100)//y1-y2,x1-x2
        //100 - 50, 100 - 100 -- 0
        //100 - 50, 100 - 150 -- 45
        //100 - 100, 100 - 150 -- 90
        //100 - 150, 100 - 150 -- 135
        //100 - 150, 100 - 100 -- 180
        //100 - 150, 100 - 50 -- 225
        //100 - 100, 100 - 50 -- 270
        //100 - 50, 100 - 50 -- 315
        //100 - 50, 100 - 100 -- 315
        //高并发限流处理=======================================================

        var thetimeouthandlerflag = 0
        var thedoingreqarr = []//存储后备要跑多少，存下标
        var thedoingreqarrAll = []//存储总共要跑多少,存具体值
        var _thetimeouthandlerFn = function (cb, v) { let num = v; cb && cb(num) }
        var thetimeouthandler = function (count, reqarr) {
            if (thetimeouthandlerflag == 1) {
                return
            }
            thetimeouthandlerflag = 1;
            //
            var maxlength = 0//跑完后的最大值
            var countlength = 0//限制跑多少
            function reqs(inds) {
                let ind = inds
                if (countlength < count) {
                    countlength++;
                    _timeouthandlerFn((v) => {
                        setTimeout(() => {
                            if (maxlength >= doingreqarrAll.length) {
                                thetimeouthandlerflag = 0
                                return;
                            }
                            if (doingreqarrAll.indexOf(v) != -1) {
                                console.log(v)
                                maxlength++;
                                countlength--;
                            } else {
                                console.log('no', v)
                            }
                            if (countlength < count) {
                                thedoingreqarr[0] && reqs(thedoingreqarr[0])
                                thedoingreqarr.splice(0, 1)
                            }
                        }, Math.random() * 7200 + 2200)
                    }, reqarr[ind])
                } else {
                    thedoingreqarr.push(ind)
                }
            }
            for (var i = 0; i < reqarr.length; i++) {
                thedoingreqarrAll.push(reqarr[i]);
                (function (ind) {
                    reqs(ind)
                })(i)
            }
            //模拟中途删除一个
            setTimeout(() => {
                //比如拿到值为4的且正在运行的下标
                countlength--;
                thedoingreqarrAll.map((item, i) => {
                    if (item == 3) {
                        thedoingreqarrAll.splice(i, 1)
                    }
                })
            }, 500)
        }
        /*
        thetimeouthandler(4, [
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
        ])*/
        //高并发(高阶解决方案，还没做异步完成任务并对应删除)==============================================
        var timecount = 4
        var timecount_now = 0
        var lastarr = []
        var lastObjFn = {}
        var maxlength = 0
        var timeouthandlerFn = (_this) => {
            const Itemhandle = function () {
                //这个方法必须消除代理问题
                this.status = 'running'
                this._this = ''
                this.pros = 0
                this.del = 0
                this.ifpause = 1
                //模拟方法
                this.baseload = {

                }
                this.loadend = 0
            }
            Itemhandle.prototype.setThis = function (cb) {
                requestAnimationFrame(() => {
                    this._this = cb && cb()
                    var length = 0
                    var flag = 0;
                    while (length < lastarr.length) {
                        lastarr[length].items == this._this.items ? flag = 1 : ''
                        if (flag == 0) { length++ } else { length = lastarr.length }
                    }
                    if (flag) {
                        this.setThis(cb)
                    } else {
                        this.del = 1
                        console.log('delete')
                    }
                })
            }
            Itemhandle.prototype.uploadbase = function () {
                var loadflag = 0
                //模拟真实api环境
                this.baseload.start = () => {
                    this.baseload.running = setTimeout(() => {
                        this.baseload.end()
                        if (this.loadend) {
                            return;
                        }
                        var canload = 0
                        var length1 = 0
                        while (length1 < lastarr.length) {
                            lastarr[length1].ifrun == 1 && lastarr[length1].items == this._this.items ? (canload = 1) : ''
                            length1++
                        }
                        if (canload == 0) return;
                        //
                        this.pros++
                        var length2 = 0
                        while (length2 < lastarr.length) {
                            lastarr[length2].items == this._this.items ? (lastarr[length2].pro = this.pros) : ''
                            length2++
                        }
                        document && (document.querySelector('#d00').innerHTML = '')
                        document && (document.querySelector('#d00').innerHTML = (JSON.stringify(lastarr)))
                        this.baseload.start()
                    }, 500)
                }
                this.baseload.pause = function () {
                    this.baseload && this.baseload.hasOwnProperty('running') && clearTimeout(this.baseload.running)
                    this.baseload && this.baseload.hasOwnProperty('running') && (this.baseload.running = null)
                }
                this.baseload.end = () => {
                    if (this.pros >= 100) {
                        this.loadend = 1
                        maxlength--;
                        var length3 = 0
                        while (length3 < lastarr.length) {
                            lastarr[length3].items == this._this.items ? (lastarr[length3].ifrun = 0) : ''
                            length3++
                        }
                        document && (document.querySelector('#d00').innerHTML = '')
                        document && (document.querySelector('#d00').innerHTML = (JSON.stringify(lastarr)))
                    }
                }
                this.baseload.error = () => {
                    setTimeout(() => {
                        var length = 0
                        while (length < lastarr.length) {
                            this._this.items == 2 && lastarr[length].items == this._this.items ? (lastarr[length].status = 'error') : ''
                            length++
                        }
                    }, 5000)
                }
                this.baseload.error()
                var fn = () => {
                    if (this.del) { this.baseload.pause(); return }
                    if (this.ifpause == 1 && loadflag == 1) {
                        loadflag = 0, this.baseload.pause()
                    } else {
                        if (this.pros >= 100) {
                            return;
                        }
                        var length = 0
                        while (length < lastarr.length) {
                            lastarr[length].ifrun == 1 && loadflag == 0 && lastarr[length].items == this._this.items ? (loadflag = 1, this.baseload.start()) : ''
                            length++
                        }
                    }
                    requestAnimationFrame(() => {
                        fn()
                    })
                }
                fn()
            }
            Itemhandle.prototype.runthesoft = function () {
                requestAnimationFrame(() => {
                    if (!this.del) {
                        if (this.ifpause == 1) {
                            return;
                        } else {
                            if (this.loadend) {
                                return;
                            }
                            var length1 = 0
                            while (length1 < lastarr.length) {
                                lastarr[length1].items == this._this.items ? (lastarr[length1].ifrun = 1) : ''
                                length1++
                            }
                            this.runthesoft()
                        }
                    }
                }, 100)
            }
            Itemhandle.prototype.thesoft = function () {
                requestAnimationFrame(() => {
                    if (!this.del) {
                        if (this.ifpause == 1) {
                            return;
                        } else {
                            if (maxlength < 4) {
                                maxlength++;
                                this.runthesoft()
                            } else {
                                this.thesoft()
                            }
                        }
                    }
                }, 100)
            }
            Itemhandle.prototype.softview = function () {
                //查询状态是否有更改并作出更改后相应的操作
                requestAnimationFrame(() => {
                    if (!this.del) {
                        var flag = 0;
                        var reloads = 0
                        var length = 0
                        while (length < lastarr.length) {
                            lastarr[length].items == this._this.items && lastarr[length].status != this.status ? (this.status = lastarr[length].status, flag = 1) : ''
                            if (flag == 0) { length++ } else { length = lastarr.length }
                        }
                        var length1 = 0
                        while (length1 < lastarr.length) {
                            lastarr[length1].items == this._this.items && lastarr[length1].reload ? (reloads = 1) : ''
                            length1++
                        }
                        if (flag == 1 && this.status == 'running') {
                            if (reloads) {
                                this.pros = 0
                                var length2 = 0
                                while (length2 < lastarr.length) {
                                    lastarr[length2].items == this._this.items ? (lastarr[length2].reload = 0, lastarr[length2].pro = 0) : ''
                                    length2++
                                }
                            }
                            this.start()
                            console.log('running')
                        }
                        if (flag == 1 && this.status == 'pause' || flag == 1 && this.status == 'error') {
                            this.pause()
                            console.log('pause')
                        }
                        this.softview()
                    }
                }, 100)
            }
            Itemhandle.prototype.start = function (cb) {
                this.ifpause = 0
                this.thesoft()
            }
            Itemhandle.prototype.pause = function (cb) {
                this.ifpause = 1
                maxlength--;
                var length = 0
                while (length < lastarr.length) {
                    lastarr[length].items == this._this.items ? (lastarr[length].ifrun = 0) : ''
                    length++
                }
            }

            return Itemhandle
        }
        var timeouthandlerOn = (arr) => {

            //拿到后处理成对象，如果本来是对象的就加上fn
            arr.map((item, i) => {
                lastarr.push({
                    items: item,
                    status: 'running',
                    ifrun: 0,
                    fn: function () {
                        timeouthandlerFn()
                        var _fn = () => {
                            return this
                        }
                        var dom = new (timeouthandlerFn())()
                        dom.setThis(function () {
                            return _fn()
                        })
                        dom.softview()
                        setTimeout(() => {
                            dom.start()
                            dom.uploadbase()
                        })
                    }
                })
                lastarr[lastarr.length - 1].fn()
            })
        }
        /*
        timeouthandlerOn([
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
        ])
        setTimeout(() => {
            timeouthandlerOn([
                16, 17, 18
            ])
        }, 3000)
        */
        /*单独操作*/
        /*
        setTimeout(() => {
            lastarr[2].status = 'pause'
            // lastarr.splice(2, 1)
        }, 2000)
        setTimeout(() => {
            lastarr[3].status = 'pause'
            // lastarr.splice(3, 1)
        }, 2000)
        setTimeout(() => {
            lastarr[2].status = 'running'
            // lastarr.splice(2, 1)
        }, 4000)
        setTimeout(() => {
            lastarr[3].status = 'running'
            // lastarr.splice(3, 1)
        }, 4000)
        setTimeout(() => {
            lastarr[8].ifrun == 1 ? (maxlength = maxlength - 1) : ''
            lastarr.splice(8, 1)
        }, 5000)
        setTimeout(() => {
            lastarr[1].reload = 1
            lastarr[1].status = 'running'
            // lastarr.splice(1, 1)
        }, 7000)
        */
        //数组和对象处理类型总结以及类型判断总结=================================
		/*
			数组#########
			push：往数组后面追加
			unshift：往数组前面追加
			pop：pop(),从数组末尾删除1个元素(删且只删除1个), 并返回 被删除的元素
			shift：shift(),在数组开始删除一个元素(删且只删除1个),并返回 被删除的元素
			join：数组拼字符串来转成新的字符串，比如arr.join(对应字符串)，传进去，然后拼接
			reverse：将数组中的元素颠倒顺序
			concat：数组拼接的功能 ,返回新数组，原数组不受影响
			indexOf：查找对应数组的下标，从前开始找
			slice：一个参数的时候，表示当前下标到数组末尾，两个参数，就是从哪个下标到数组哪个位置截取出来，不影响原数组
				单独一个参数为负数，就是倒数第几个位置到结尾
				第二个参数为负数的时候，表示从哪个下标开始到后面倒数第几个位置，且不包括当前位置
			splice：一个参数，表示从第几个开始删除，两个参数，表示第几个起删除第二个参数的数量值，再往后加参数就是删完之后追加（仅限从第三个参数开始一直追加新的参数）
			{
				-- 以下方法很难兼容ie，需做兼容处理（传统异能重写类似实现的方法）
				纯移动端直接使用 --
			}
			lastIndexOf：查找对应数组的下标，从后开始找//
			sort：排序，类似于冒泡排序，加个回调并返回a-b两个参数相减，可以做到对象形式排序
			filter：过滤功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。
				比如：去重
				arr.filter(function(v,i,self){
				  return self.indexOf(v) == i;
				});
			every：所有都满足条件，返回true，arr.every(条件)
			some：有一个满足条件，返回true，arr.some(条件)
			对象##########
			Object.assign({},obj)，obj为要拼接进去的对象
			JSON.parse(obj字符串)，转为正式对象
			JSON.stringify(obj)，转为字符串对象
			类型判断##########
			typeof：null，arr，obj都返回object，数字和NaN都返回number，其他的一一对应
			constructor返回的类型要比typeof更准确一点，可以细分object，
			instanceof 也可以，比如 [1,2].instanceof Array == true，但在不同window或者iframe间，不能使用instanceof
		 */
	</script>
</body>

</html>